package com.synface.utils;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

public class JSONUtils
{
  public static boolean isPrintException = true;

  private JSONUtils() {
    throw new AssertionError();
  }

  public static Long getLong(JSONObject jsonObject, String key, Long defaultValue)
  {
    if ((jsonObject == null) || (com.synface.utils.StringUtils.isEmpty(key))) {
      return defaultValue;
    }
    try
    {
      return Long.valueOf(jsonObject.getLong(key));
    } catch (JSONException e) {
      if (isPrintException)
        e.printStackTrace();
    }
    return defaultValue;
  }

  public static Long getLong(String jsonData, String key, Long defaultValue)
  {
    if (com.synface.utils.StringUtils.isEmpty(jsonData)) {
      return defaultValue;
    }
    try
    {
      JSONObject jsonObject = new JSONObject(jsonData);
      return getLong(jsonObject, key, defaultValue);
    } catch (JSONException e) {
      if (isPrintException)
        e.printStackTrace();
    }
    return defaultValue;
  }

  public static long getLong(JSONObject jsonObject, String key, long defaultValue)
  {
    return getLong(jsonObject, key, Long.valueOf(defaultValue)).longValue();
  }

  public static long getLong(String jsonData, String key, long defaultValue)
  {
    return getLong(jsonData, key, Long.valueOf(defaultValue)).longValue();
  }

  public static Integer getInt(JSONObject jsonObject, String key, Integer defaultValue)
  {
    if ((jsonObject == null) || (com.synface.utils.StringUtils.isEmpty(key))) {
      return defaultValue;
    }
    try
    {
      return Integer.valueOf(jsonObject.getInt(key));
    } catch (JSONException e) {
      if (isPrintException)
        e.printStackTrace();
    }
    return defaultValue;
  }

  public static Integer getInt(String jsonData, String key, Integer defaultValue)
  {
    if (com.synface.utils.StringUtils.isEmpty(jsonData)) {
      return defaultValue;
    }
    try
    {
      JSONObject jsonObject = new JSONObject(jsonData);
      return getInt(jsonObject, key, defaultValue);
    } catch (JSONException e) {
      if (isPrintException)
        e.printStackTrace();
    }
    return defaultValue;
  }

  public static int getInt(JSONObject jsonObject, String key, int defaultValue)
  {
    return getInt(jsonObject, key, Integer.valueOf(defaultValue)).intValue();
  }

  public static int getInt(String jsonData, String key, int defaultValue)
  {
    return getInt(jsonData, key, Integer.valueOf(defaultValue)).intValue();
  }

  public static Double getDouble(JSONObject jsonObject, String key, Double defaultValue)
  {
    if ((jsonObject == null) || (com.synface.utils.StringUtils.isEmpty(key))) {
      return defaultValue;
    }
    try
    {
      return Double.valueOf(jsonObject.getDouble(key));
    } catch (JSONException e) {
      if (isPrintException)
        e.printStackTrace();
    }
    return defaultValue;
  }

  public static Double getDouble(String jsonData, String key, Double defaultValue)
  {
    if (com.synface.utils.StringUtils.isEmpty(jsonData)) {
      return defaultValue;
    }
    try
    {
      JSONObject jsonObject = new JSONObject(jsonData);
      return getDouble(jsonObject, key, defaultValue);
    } catch (JSONException e) {
      if (isPrintException)
        e.printStackTrace();
    }
    return defaultValue;
  }

  public static double getDouble(JSONObject jsonObject, String key, double defaultValue)
  {
    return getDouble(jsonObject, key, Double.valueOf(defaultValue)).doubleValue();
  }

  public static double getDouble(String jsonData, String key, double defaultValue)
  {
    return getDouble(jsonData, key, Double.valueOf(defaultValue)).doubleValue();
  }

  public static String getString(JSONObject jsonObject, String key, String defaultValue)
  {
    if ((jsonObject == null) || (com.synface.utils.StringUtils.isEmpty(key))) {
      return defaultValue;
    }
    try
    {
      return jsonObject.getString(key);
    } catch (JSONException e) {
      if (isPrintException)
        e.printStackTrace();
    }
    return defaultValue;
  }

  public static String getString(String jsonData, String key, String defaultValue)
  {
    if (com.synface.utils.StringUtils.isEmpty(jsonData)) {
      return defaultValue;
    }
    try
    {
      JSONObject jsonObject = new JSONObject(jsonData);
      return getString(jsonObject, key, defaultValue);
    } catch (JSONException e) {
      if (isPrintException)
        e.printStackTrace();
    }
    return defaultValue;
  }

  public static String getStringCascade(JSONObject jsonObject, String defaultValue, String[] keyArray)
  {
    if ((jsonObject == null) || (ArrayUtils.isEmpty(keyArray))) {
      return defaultValue;
    }

    String data = jsonObject.toString();
    for (String key : keyArray) {
      data = getStringCascade(data, key, new String[] { defaultValue });
      if (data == null) {
        return defaultValue;
      }
    }
    return data;
  }

  public static String getStringCascade(String jsonData, String defaultValue, String[] keyArray)
  {
    if (com.synface.utils.StringUtils.isEmpty(jsonData)) {
      return defaultValue;
    }

    String data = jsonData;
    for (String key : keyArray) {
      data = getString(data, key, defaultValue);
      if (data == null) {
        return defaultValue;
      }
    }
    return data;
  }

  public static String[] getStringArray(JSONObject jsonObject, String key, String[] defaultValue)
  {
    if ((jsonObject == null) || (com.synface.utils.StringUtils.isEmpty(key))) {
      return defaultValue;
    }
    try
    {
      JSONArray statusArray = jsonObject.getJSONArray(key);
      if (statusArray != null) {
        String[] value = new String[statusArray.length()];
        for (int i = 0; i < statusArray.length(); ++i) {
          value[i] = statusArray.getString(i);
        }
        return value;
      }
    } catch (JSONException e) {
      if (isPrintException) {
        e.printStackTrace();
      }
      return defaultValue;
    }
    return defaultValue;
  }

  public static String[] getStringArray(String jsonData, String key, String[] defaultValue)
  {
    if (com.synface.utils.StringUtils.isEmpty(jsonData)) {
      return defaultValue;
    }
    try
    {
      JSONObject jsonObject = new JSONObject(jsonData);
      return getStringArray(jsonObject, key, defaultValue);
    } catch (JSONException e) {
      if (isPrintException)
        e.printStackTrace();
    }
    return defaultValue;
  }

  public static List<String> getStringList(JSONObject jsonObject, String key, List<String> defaultValue)
  {
    if ((jsonObject == null) || (com.synface.utils.StringUtils.isEmpty(key))) {
      return defaultValue;
    }
    try
    {
      JSONArray statusArray = jsonObject.getJSONArray(key);
      if (statusArray != null) {
        List list = new ArrayList();
        for (int i = 0; i < statusArray.length(); ++i) {
          list.add(statusArray.getString(i));
        }
        return list;
      }
    } catch (JSONException e) {
      if (isPrintException) {
        e.printStackTrace();
      }
      return defaultValue;
    }
    return defaultValue;
  }

  public static List<String> getStringList(String jsonData, String key, List<String> defaultValue)
  {
    if (com.synface.utils.StringUtils.isEmpty(jsonData)) {
      return defaultValue;
    }
    try
    {
      JSONObject jsonObject = new JSONObject(jsonData);
      return getStringList(jsonObject, key, defaultValue);
    } catch (JSONException e) {
      if (isPrintException)
        e.printStackTrace();
    }
    return defaultValue;
  }

  public static JSONObject getJSONObject(JSONObject jsonObject, String key, JSONObject defaultValue)
  {
    if ((jsonObject == null) || (com.synface.utils.StringUtils.isEmpty(key))) {
      return defaultValue;
    }
    try
    {
      return jsonObject.getJSONObject(key);
    } catch (JSONException e) {
      if (isPrintException)
        e.printStackTrace();
    }
    return defaultValue;
  }

  public static JSONObject getJSONObject(String jsonData, String key, JSONObject defaultValue)
  {
    if (com.synface.utils.StringUtils.isEmpty(jsonData)) {
      return defaultValue;
    }
    try
    {
      JSONObject jsonObject = new JSONObject(jsonData);
      return getJSONObject(jsonObject, key, defaultValue);
    } catch (JSONException e) {
      if (isPrintException)
        e.printStackTrace();
    }
    return defaultValue;
  }

  public static JSONObject getJSONObjectCascade(JSONObject jsonObject, JSONObject defaultValue, String[] keyArray)
  {
    if ((jsonObject == null) || (ArrayUtils.isEmpty(keyArray))) {
      return defaultValue;
    }

    JSONObject js = jsonObject;
    for (String key : keyArray) {
      js = getJSONObject(js, key, defaultValue);
      if (js == null) {
        return defaultValue;
      }
    }
    return js;
  }

  public static JSONObject getJSONObjectCascade(String jsonData, JSONObject defaultValue, String[] keyArray)
  {
    if (com.synface.utils.StringUtils.isEmpty(jsonData)) {
      return defaultValue;
    }
    try
    {
      JSONObject jsonObject = new JSONObject(jsonData);
      return getJSONObjectCascade(jsonObject, defaultValue, keyArray);
    } catch (JSONException e) {
      if (isPrintException)
        e.printStackTrace();
    }
    return defaultValue;
  }

  public static JSONArray getJSONArray(JSONObject jsonObject, String key, JSONArray defaultValue)
  {
    if ((jsonObject == null) || (com.synface.utils.StringUtils.isEmpty(key))) {
      return defaultValue;
    }
    try
    {
      return jsonObject.getJSONArray(key);
    } catch (JSONException e) {
      if (isPrintException)
        e.printStackTrace();
    }
    return defaultValue;
  }

  public static JSONArray getJSONArray(String jsonData, String key, JSONArray defaultValue)
  {
    if (com.synface.utils.StringUtils.isEmpty(jsonData)) {
      return defaultValue;
    }
    try
    {
      JSONObject jsonObject = new JSONObject(jsonData);
      return getJSONArray(jsonObject, key, defaultValue);
    } catch (JSONException e) {
      if (isPrintException)
        e.printStackTrace();
    }
    return defaultValue;
  }

  public static boolean getBoolean(JSONObject jsonObject, String key, Boolean defaultValue)
  {
    if ((jsonObject == null) || (com.synface.utils.StringUtils.isEmpty(key))) {
      return defaultValue.booleanValue();
    }
    try
    {
      return jsonObject.getBoolean(key);
    } catch (JSONException e) {
      if (isPrintException)
        e.printStackTrace();
    }
    return defaultValue.booleanValue();
  }

  public static boolean getBoolean(String jsonData, String key, Boolean defaultValue)
  {
    if (com.synface.utils.StringUtils.isEmpty(jsonData)) {
      return defaultValue.booleanValue();
    }
    try
    {
      JSONObject jsonObject = new JSONObject(jsonData);
      return getBoolean(jsonObject, key, defaultValue);
    } catch (JSONException e) {
      if (isPrintException)
        e.printStackTrace();
    }
    return defaultValue.booleanValue();
  }

  public static Map<String, String> getMap(JSONObject jsonObject, String key)
  {
    return parseKeyAndValueToMap(getString(jsonObject, key, null));
  }

  public static Map<String, String> getMap(String jsonData, String key)
  {
    if (jsonData == null) {
      return null;
    }
    if (jsonData.length() == 0) {
      return new HashMap();
    }
    try
    {
      JSONObject jsonObject = new JSONObject(jsonData);
      return getMap(jsonObject, key);
    } catch (JSONException e) {
      if (isPrintException)
        e.printStackTrace();
    }
    return null;
  }

  public static Map<String, String> parseKeyAndValueToMap(JSONObject sourceObj)
  {
    if (sourceObj == null) {
      return null;
    }

    Map keyAndValueMap = new HashMap();
    for (Iterator iter = sourceObj.keys(); iter.hasNext(); ) {
      String key = (String)iter.next();
      com.synface.utils.MapUtils.putMapNotEmptyKey(keyAndValueMap, key,
        getString(sourceObj, key, ""));
    }

    return keyAndValueMap;
  }

  public static Map<String, String> parseKeyAndValueToMap(String source)
  {
    if (com.synface.utils.StringUtils.isEmpty(source)) {
      return null;
    }
    try
    {
      JSONObject jsonObject = new JSONObject(source);
      return parseKeyAndValueToMap(jsonObject);
    } catch (JSONException e) {
      if (isPrintException)
        e.printStackTrace();
    }
    return null;
  }

  public static JSONObject parseMapToJson(Map<String, String> map)
  {
    JSONObject jsonObject = new JSONObject();
    for (String key : map.keySet()) {
      try {
        jsonObject.put(key, map.get(key));
      } catch (JSONException e) {
        e.printStackTrace();
        return null;
      }
    }
    return jsonObject;
  }

  public static JSONObject parseByteToJson(byte[] b) {
    if (b == null) {
      return new JSONObject();
    }
    String response = new String(b);
    JSONObject jsonObject = null;
    try {
      jsonObject = new JSONObject(response);
    } catch (JSONException e) {
      e.printStackTrace();
      return new JSONObject();
    }
    return jsonObject;
  }

  public static JSONArray parseByteToJsonArray(byte[] b) {
    if (b == null) {
      return new JSONArray();
    }
    String response = new String(b);
    JSONArray jsonArray = null;
    try {
      jsonArray = new JSONArray(response);
    } catch (JSONException e) {
      e.printStackTrace();
      return new JSONArray();
    }
    return jsonArray;
  }

  public static JSONObject parseStringToJson(String s) {
    JSONObject jsonObject = null;
    try {
      jsonObject = new JSONObject(s);
    } catch (JSONException e) {
      e.printStackTrace();
      return new JSONObject();
    }
    return jsonObject;
  }
}